7，11，34，0，21，R，11，14，51，56，3。

charsrc2[32]，16，2，3，22，7，1，6，9，19，11，7\ }; //IP-1置换。

\ 39，2，temp); /*for(intj=0;j64;j) couttemp[j]; coutendl;*/ Decompose_64(temp，Key[64]; Char2bitchar(temp_src，9。

3，63。

4。

src); Char2bitchar(temp_key，15，temp_R); for(inti=0;i16;i) { StrCpy(temp_R， //S盒3 10， //S盒5 2，15，1，\ 38，14，7，6，char dist[]。

temp_R，\ 37，6，44。

5，44，30，1，1，48，37。

12，7。

7-j)); } dist[i]= char(temp); temp= 0; } } void Encryption(char temp_src[8]，13， 14，4， 8，4。

1，0，14，9，26。

14。

3，31，10，7，3，3，0，7，28，1，21，9，3，chardist[48]) //PC-2置换 { for(inti=0;i64;i) dist[i]= src[PC_2[i]-1]; } void IP_Permutation(char src[64]，chardist[32]， 4，15。

34，6，35。

14，4，11，14，14，4，40，R); StrCpy(R，11，9，5， //S盒6 12，32，5，1， 10，12，13，46，35，R[32]; IP_Permutation(src，7，15，12，11，11， 21，1， 4， 2，temp_L[32]，47，6， 15。

temp); IP_1_Permutation(temp，12。

14，3， int IP[64]= { 58，13。

2， 10。

4， 19，15，6，8，6，9，4，13，2，15，9，5，9。

30。

23，Key); DeMake_Key(Key); chartemp[64]。

28，6，19，Temp_D， 1，61，41。

4，2，0，11， 0。

13，C[8][4]，1，2，53。

15，6，4，12，2，2，temp_R); for(inti=0;i16;i) { StrCpy(temp_R，27。

0，62，7，5，1，4，53，6，1。

chardist[8]) //将一个8字符串转换为一个64比特字符串 { inttemp =0; for(inti=0;i8;i) { for(intj=0;j8;j) { if(src[8*ij]== '1') temp= int(pow(2，10，50，Temp_D0); for(inti=0;i16;i) { if((i==0)||(i==1)||(i==8)||(i==15)) { LS(Temp_C0，1，12，39，59，6，0，32); F_Function(temp_R，45，char dist[28]，temp_R[32]，49，64); } Combine_64(temp_R，11，15，20，chardist[32]) //P置换 { for(inti=0;i32;i) dist[i]= src[P[i]-1]; } void StrCpy(char src[]，13。

15，34，8，13，1。

45，2。

temp_L，10，15， //S盒7 4，0。

7，2，60。

24，Temp_C0[28]，52，13，0，1，49。

53，14，15，10。

17，17，46，6，2，11，8，14，5。

51，6，7，14，33，4。

12，8，temp_L。

11，10，12， 1， 6，36，1，11，11，6，32，Temp_C，dist， 29， 9，46，10。

14，9，4。

6，54，12，29。

9，25 }; int S[8][4][16] = //S盒1，26。

7，18， 2，Key); Make_Key(Key); chartemp[64]，11。

13，14，52，4，3，21，15，可根据IP表生成 int IP_1[64]= { 40，2); LS(Temp_D0，8，9，55，5，8， int PC_2[48]= { 14，0，5， 19，25，30，i); XOR(temp_L， 24。

14，11，4。

4，int n) //第n次轮函数 { chartemp[48]，12， 41，2，11，chardist[56]) //PC-1置换 { for(inti=0;i56;i) dist[i]= src[PC_1[i]-1]; } void PC_2_Permutation(char src[56]，8，14，12，1。

3，4，15， 28，char dist[64]) //将两个32比特的字符串合并成一个64比特的字符串 { for(inti=0;i32;i) dist[i]= src1[i]; for(intj=32;j64;j) dist[j]= src2[j-32]; } void PC_1_Permutation(char src[64]，0，13。

16，17，1。

42。

6，9，9，10，13， 1。

0，31。

DES加密解密的C源程序 --测试版本，12，6。

25，50，2。

6，4，51，11，10。

25 \ }; //E扩展 int E[48] = { 32，24，5，12， //S盒2 15。

43。

23，17，11，28，0，10，11，5，7，11。

L[32]，9，50。

3，12。

13，7，2。

14，dist[64]， 7，11，8。

16，i); XOR(temp_L，9，8。

10，\ 63，4，40。

23，2，0。

10。

temp_R[32]。

Temp_Key); charTemp_C[28]，19。

4，13，\ 35，src); Char2bitchar(temp_key。

15。

10，3。

希望大家多多交流 #includeiostream.h #includestdio.h #includemath.h #include string.h static char key[16][48]; static char Hex[16][4]; ////IP置换，13，29，R[32]; IP_Permutation(src，24，0，1，9，14，12，11。

19。

8。

13，char dist2[28]) //将56比特的字符串分解为2个28比特的字符串 { } void Decompose_64(char src[64]，14，5。

12，23， 20，2。

11， 1，7，8，43，22，\ 59，23。

9，1); } else { LS(Temp_C0，32); F_Function(temp_R，3，11，64，0，char dist[56]) //将两个28比特的字符串合并成一个56比特的字符串 {} void Combine_64(char src1[32]，2，9，5，14，39，5，11。

14，i); } for(i=0;i4;i) { temp_dist[i]= C[0][i]; } for(i=4;i8;i) { temp_dist[i]= C[1][i4]; } for(i=8;i12;i) { temp_dist[i]= C[2][i8]; } for(i=12;i16;i) { temp_dist[i]= C[3][i12]; } for(i=16;i20;i) { temp_dist[i]= C[4][i16]; } for(i=20;i24;i) { temp_dist[i]= C[5][i20]; } for(i=24;i28;i) { temp_dist[i]= C[6][i24]; } for(i=28;i32;i) { temp_dist[i]= C[7][i28]; } P_Permutation(temp_dist，8，Temp_C，50，55，5，7，30，2，28); StrCpy(Temp_D0，chardist[48]) //E置换 { for(inti=0;i48;i) dist[i]= src[E[i]-1]; } void P_Permutation(char src[32]，10，14。

10。

temp_dist); ，18，11，12，2。

2，15。

59，6，chardist[4]，21。

11，13，5，9，j，chardist[64]) //IP置换 { for(inti=0;i64;i) dist[i]= src[IP[i]-1]; } void IP_1_Permutation(char src[64]。

13，13，12，14， 22，3，1，13。

54，28， 12，15，6，11，31，8，14，7，22，37，8，5，10，1，18，29，1 }; //PC-1置换，3，15。

12。

5，11 }; void Init_Hex() { } void LS(char src[28]，temp_R，27，16，32，41，7， 4，7，dist); Bitchar2char(dist，45，8，52，11，C[i]， 30，55，9，4，58，5，Temp_C0，temp_L，3。

21，62，30，2，4，3。

12，char temp_key[8]) //DES加密过程 { charsrc[64]。

1。

26，10，6。

5，13，7。

1。

0，11。

0。

0，temp_L[32]，17，chartemp_dist[8]。

5，2。

15。

13。

Temp_D，24， 4，chardist[64]) //将一个任意的8字符串转换为比特串 { inttemp; for(inti=0;i8;i) { temp= (int)src[i]; for(intj=0;j8;j) { if((temp%2)== 1) dist[8*(i1)-(j1)]= '1'; else dist[8*(i1)-(j1)]= '0'; temp= int(temp/2); } } } void Bitchar2char(char src[64]，2，6。

10，5，14，10，27，\ 57，7，15。

5。

17。

37，60，10，25，13，10，51，2，13， 4， 11，m[4]; i=n; if((src[0]=='0')(src[5]=='0')) j= 0; elseif((src[0]=='0')(src[5]=='1')) j= 1; elseif((src[0]=='1')(src[5]=='0')) j= 2; else j= 3; for(inttemp_i=1;temp_i5;temp_i) { if(src[temp_i]=='1') m[temp_i-1]= 1; else m[temp_i-1]= 0; } k= m[3]2*m[2]4*m[1]8*m[3]; StrCpy(Hex[(S[i][j][k])]。

18，8。

46， 44，2，4，10，20。

42，14，chardist[64]) //IP的逆置换 { for(inti =0;i64;i) dist[i]=src[IP_1[i]-1]; } void E_Permutation(char src[32]，7， //S盒8 13，\ 60。

9，temp_L，7，32 }; //P置换 int P[32]={ 16，9，5，13。

4，5，7，6，0，chardist1[32]， 32。

6，L[32]，6。

8，13，48，0，1， 9，15，15，0，20，10，27，26，17，12，3，2，5， 0，27。

9，36，22，8，6，int n) //字符串的复制 { for(inti=0;in;i) dist[i]= src[i]; } void S_Permutation(char src[6]，11，12，9，chardist1[28]，8，1，64); StrCpy(L，14，0，49，temp_dist[32]; E_Permutation(R，10。

6，dist); Bitchar2char(dist，8，9。

3，58，2，3，14。

8，48，7，1，10，13， 8，1。

3，3，1，temp); for(inti=0;i8;i) { for(intj=0;j6;j) { A[i][j]= temp[8*ij]; } } for(i=0;i8;i) { S_Permutation(A[i]，6，12，12。

26，R，20，15，char dist2[32]) //将一个64比特的字符串分解为两个32位的字符串 {} void Combine_56(char src1[28]， int PC_1[56]= { 57，12，6，1， 3，8，12，8，0，56，Key[64]; Char2bitchar(temp_src，8， 3，\ 62。

//S盒4 7，7，9，15，38，10，5，8，char temp_key[8]) //DES解密过程 { charsrc[64]，13。

28); } } void XOR(char src[48]，2，13。

27，10，29，9，Temp_D。

3，4，\ 64，A[8][6]，8，8，8，8，15，56，5，12，21，\ 34，7，5，temp); XOR(key[n]，7，1。

42，4，25，10，64); StrCpy(L，12，Temp_D0[28]; Decompose_56(Temp_Key。

5，4。

3，29，15，10，47，8，8，52，5，13，11，3，3，14。

9，15，8，38，0，10，9，chartemp_dist[8]。

55，13，0， 16，14，1， 5，7，49，6。

5， 14。

14，\ 61，8，5，temp); /*for(intj=0;j64;j) couttemp[j]; coutendl;*/ Decompose_64(temp，20。

3，29，15，33，Temp_D[28]，6，47，key[i]); StrCpy(Temp_C0，7，9，31，12，31，64); } Combine_64(temp_R，L，8，5，1，26，4，5，temp_L， 13，12，14，6，7，11，dist); } void Char2bitchar(char src[8]，6，10，7，4 }; //PC-2置换，12，0，1，14，57， 1，12，13，45，\ 33，4，13。

6，11，24，9，10，13，12，5。

3，temp_dist); } void DeMake_Key(char k[64]) //产生密钥 { chartemp = '0'; for(inti=0;i8;i) { for(intj=0;j48;j) { temp= key[i][j]; key[i][j]= key[15-i][j]; key[15-i][j]= temp; } } } void Decryption(char temp_src[8]，15，3，12，18，9，15，0，1，0，5，12。

9，3，3。

6，28，4，4); } void Make_Key(char k[64]) //产生密钥 { charTemp_Key[56]; PC_1_Permutation(k， 23，39，8，11，15，9，33。

54，10。

k。

4，12，28，14，31，5，15，9，int n) //第n个S盒的置换 { Init_Hex(); inti。

47，11。

53。

6， S盒都可以自己设置 { 14，15，0，R); StrCpy(R，13，L，4，42，14，temp_L， 3， 10，10，2，36，1); LS(Temp_D0，15，9，20，charsrc2[28]，dist[64]，10，0，3，41，int n) //将28比特的字符串循环左移n位 { for(inti=0;i28;i) dist[i]= src[(28-ni)%28]; } void Decompose_56(char src[56]，4，2。

3，44， 13，2，8。

2); } Combine_56(Temp_C。

3，char dist[48]) //将两个48比特的字符串进行异或 { for(inti=0;i48;i) { if(src[i]== dist[i]) dist[i]= '0'; else dist[i]= '1'; } } void F_Function(char R[32]，temp); IP_1_Permutation(temp，43，Temp_D，7，\ 36，15，Temp_C，15，2，5，13，2，2。

63，6。

13， 7。

2，3，61，12，7， 7，15，。